home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Modules / BackSpaceModules / Source / IconMosaicView / IconMosaicView.m < prev    next >
Encoding:
Text File  |  1993-01-28  |  7.6 KB  |  317 lines
  1. /* IconMosaicView.m -- copyright 1993 by Christopher Lane */
  2.  
  3. #import <c.h>
  4. #import <sys/dir.h>
  5. #import <mach-o/loader.h>
  6. #import <appkit/appkit.h>
  7.  
  8. #import "Thinker.h"
  9. #import "DefaultsTable.h"
  10. #import "IconMosaicView.h"
  11.  
  12. #define MODULE "IconMosaic"
  13. #define DEFAULTSFILE "Defaults.strings"
  14.  
  15. #define IMAGEPATHS getDefault("IconMosaicImagePaths")
  16. #define SEGMENTLIST getDefault("IconMosaicSegmentList")
  17. #define IMAGESUFFIXLIST getDefault("IconMosaicImageSuffixList")
  18. #define APPSUFFIXLIST getDefault("IconMosaicApplicationSuffixList")
  19. #define IGNORESECTIONLIST getDefault("IconMosaicIgnoreSectionList")
  20.  
  21. #define MAXIMUMSIZE getSizeDefault("IconMosaicMaximumSize")
  22. #define MAXIMUMBYTES getIntDefault("IconMosaicMaximumBytes")
  23.  
  24. #define DENSITYDEFAULTNAME "IconMosaicDensity"
  25. #define DENSITY getFloatDefault(DENSITYDEFAULTNAME)
  26.  
  27. #define PATHSEPARATOR "/"
  28. #define PATHSEPARATORCHAR (PATHSEPARATOR)[0]
  29. #define TOKENSEPARATOR ":"
  30. #define TOKENSEPARATORCHAR (TOKENSEPARATOR)[0]
  31. #define EXTENSIONSEPARATOR "."
  32. #define EXTENSIONSEPARATORCHAR (EXTENSIONSEPARATOR)[0]
  33.  
  34. @implementation IconMosaicView
  35.  
  36. static any_t search(id self)
  37. {
  38.     char *path, *paths = NXCopyStringBuffer(IMAGEPATHS);
  39.     
  40.     for(path = strtok(paths, TOKENSEPARATOR); path != NULL; path = strtok(NULL, TOKENSEPARATOR))
  41.         [self loadImagesFromDirectory:path];
  42.         
  43.     NX_FREE(paths);
  44.     
  45.     return self;
  46. }
  47.  
  48. - initFrame:(NXRect *) frameRect
  49. {
  50.     char buffer[MAXPATHLEN];
  51.     
  52.     [super initFrame:frameRect];
  53.  
  54.     [self allocateGState];
  55.  
  56.     images = [[List alloc] init];
  57.     
  58.     inspector = field = nil;
  59.     
  60.     thread = NO_CTHREAD;
  61.     
  62.     lock = mutex_alloc();
  63.     condition = condition_alloc();
  64.     
  65.     (void) sprintf(buffer,"%s/%s", [[NXApp delegate] moduleDirectory:MODULE], DEFAULTSFILE);
  66.     [(defaults = [[DefaultsTable alloc] initFromFile:buffer]) registerDefaults:[NXApp appName]];
  67.  
  68.     maximumSize = MAXIMUMSIZE;
  69.     
  70.     maximumBytes = MAXIMUMBYTES;
  71.     
  72.     srandom(time(NULL));
  73.     
  74.     return self;
  75. }
  76.  
  77. - drawSelf:(const NXRect *) rects :(int) rectCount
  78. {
  79.     if (rects == NULL || rectCount == 0) return self;
  80.     
  81.     PSsetgray(NX_BLACK);
  82.  
  83.     NXRectFill(rects);
  84.  
  85.     return self;
  86. }
  87.  
  88. - didLockFocus
  89. {
  90.     if(thread == NO_CTHREAD) cthread_detach(thread = cthread_fork((cthread_fn_t) search, (any_t) self));
  91.         
  92.     return self;
  93. }
  94.  
  95. - free
  96. {
  97.     mutex_lock(lock); {
  98.         [[images freeObjects] free];
  99.         (void) cthread_abort(thread);
  100.         } mutex_unlock(lock);
  101.         
  102.     return [super free];
  103. }
  104.  
  105. - oneStep
  106. {
  107.     id image;
  108.     NXSize size;
  109.     unsigned int count;
  110.     NXPoint point = { 0, 1 };
  111.     
  112.     condition_signal(condition);
  113.     
  114.     [self scrollRect:&bounds by:&point];
  115.     
  116.     if(((random() % 100) / 100.0) > [density floatValue]) return self;
  117.     
  118.     mutex_lock(lock); {
  119.         count = [images count];
  120.         } mutex_unlock(lock);
  121.     
  122.     if(count < 1) return self;
  123.     
  124.     mutex_lock(lock); {
  125.         [(image = [images objectAt:(random() % count)]) getSize:&size];
  126.         } mutex_unlock(lock);
  127.  
  128.     point.x = random() % (int) (bounds.size.width - size.width);
  129.  
  130.     [image composite:NX_SOVER toPoint:&point];
  131.     
  132.     if(field != nil && [field intValue] < count) [field setIntValue:count];
  133.  
  134.     return self;
  135. }
  136.  
  137. - inspector:sender
  138. {
  139.     char buffer[MAXPATHLEN];
  140.  
  141.     if (inspector == nil) {
  142.         (void) sprintf(buffer,"%s/%s.nib", [sender moduleDirectory:MODULE], MODULE);
  143.         [NXApp loadNibFile:buffer owner:self withNames:NO];
  144.         }
  145.  
  146.     return inspector;
  147. }
  148.  
  149. - inspectorInstalled
  150. { 
  151.     mutex_lock(lock); {
  152.         [field setIntValue:[images count]];
  153.         } mutex_unlock(lock);
  154.  
  155.      return self;
  156. }
  157.  
  158. - (BOOL) useBufferedWindow { return YES; }
  159.  
  160. - (const char *) windowTitle { return MODULE; }
  161.  
  162. - setDefault:sender
  163. {
  164.     [sender setTag:YES];
  165.     
  166.     if([density tag]) (void) writeDefault(DENSITYDEFAULTNAME, [density stringValue]);
  167.  
  168.     return self;
  169. }
  170.  
  171. - setDensity:anObject
  172. {
  173.     [(density = anObject) setFloatValue:DENSITY];
  174.     
  175.     return self;
  176. }
  177.  
  178. - (BOOL) loadFromStream:(NXStream *) stream
  179. {
  180.     NXSize size;
  181.     BOOL result = NO;
  182.     NXImage *image = [[NXImage alloc] init];
  183.  
  184.     if([image loadFromStream:stream]) {
  185.         [image getSize:&size];
  186.         if(size.width <= maximumSize.width && size.height <= maximumSize.height) {
  187.             mutex_lock(lock); {
  188.                 [images addObject:image];
  189.                 condition_wait(condition, lock);
  190.                 } mutex_unlock(lock);
  191.             result = YES;
  192.             }
  193.         else [image free];
  194.         }
  195.     else [image free];
  196.     
  197.     return result;
  198. }
  199.  
  200. - (BOOL) member:(const char *) item ofSet:(const char *) set
  201. {
  202.     BOOL result = NO;
  203.     char *r, *s, *buffer = NXCopyStringBuffer(set);
  204.     int index, length, itemLength = strlen(item);
  205.     
  206.     r = buffer;
  207.     
  208.     while((s = r) != NULL) {
  209.         if((r = index(s, TOKENSEPARATORCHAR)) != NULL) *r++ = '\0';
  210.         
  211.         if((length = strlen(s)) > itemLength) continue;
  212.         else index = itemLength - length;
  213.         
  214.         if(result = (strncmp(s, item + index, length) == 0)) break;
  215.         }
  216.         
  217.     NX_FREE(buffer);
  218.     
  219.     return result;
  220. }
  221.  
  222. - loadImagesFromDirectory:(const char *) directory
  223. {
  224.     struct stat fs;
  225.     NXStream *stream;
  226.     struct direct *dp;
  227.     char buffer[MAXPATHLEN];
  228.     DIR *dirp = opendir(directory);
  229.     
  230.     if(dirp == NULL) return nil;
  231.  
  232.     for(dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
  233.         (void) strcat(strcat(strcpy(buffer, directory), PATHSEPARATOR), dp->d_name);
  234.         if(stat(buffer, &fs) == CERROR) continue;
  235.         else if(fs.st_mode & S_IFDIR && (dp->d_name)[0] != EXTENSIONSEPARATORCHAR) [self loadImagesFromDirectory:buffer];
  236.         else if(fs.st_size <= maximumBytes && [self member:dp->d_name ofSet:IMAGESUFFIXLIST]) {
  237.             if((stream = NXMapFile(buffer, NX_READONLY)) != NULL) {
  238.                 if([self loadFromStream:stream]) {
  239. #ifdef DEBUG
  240.                     (void) fprintf(stderr, "%s\n", buffer);
  241.                     }
  242.                 else {
  243.                     (void) fprintf(stderr, "%s -- failed\n", buffer);
  244. #endif
  245.                     }
  246.                 NXCloseMemory(stream, NX_FREEBUFFER);
  247.                 }
  248.             }
  249.         else if(fs.st_mode & S_IEXEC && fs.st_mode & S_IFREG) [self loadImagesFromSegment:buffer];
  250.         }
  251.  
  252.     (void) closedir(dirp);
  253.     
  254.     return self;
  255. }
  256.  
  257. - loadImagesFromSegment:(const char *) filename
  258. {
  259.     long offset;
  260.     char *buffer;
  261.     unsigned int i;
  262.     NXStream *stream, *memory;
  263.     unsigned long ncmds, nsects;
  264.  
  265.     struct mach_header m_header;
  266.     struct load_command l_command;
  267.     struct segment_command s_command;
  268.     struct section s_section;
  269.  
  270.     if ((stream = NXMapFile(filename, NX_READONLY)) == NULL) return nil;
  271.     if (NXRead(stream, &m_header, sizeof(m_header)) == sizeof(m_header) && m_header.magic == MH_MAGIC) {
  272.     
  273.         for (ncmds = m_header.ncmds; ncmds > 0; ncmds--) {
  274.             offset = NXTell(stream);
  275.             if (NXRead(stream, &l_command, sizeof(l_command)) != sizeof(l_command)) break;
  276.             if (l_command.cmd == LC_SEGMENT) {
  277.                 NXSeek(stream, offset, NX_FROMSTART);
  278.                 if (NXRead(stream, &s_command, sizeof(s_command)) != sizeof(s_command)) break;
  279.                 if([self member:s_command.segname ofSet:SEGMENTLIST]) {
  280.                     for (nsects = 0; nsects < s_command.nsects; nsects++) {
  281.                         if (NXRead(stream, &s_section, sizeof(s_section)) != sizeof(s_section)) continue;
  282.                         else if(s_section.size > maximumBytes || [self member:s_section.sectname ofSet:IGNORESECTIONLIST]) continue;
  283.                     
  284.                         offset = NXTell(stream);
  285.                         NXSeek(stream, s_section.offset, NX_FROMSTART);
  286.  
  287.                         (void) vm_allocate(task_self(), (vm_address_t *) &buffer, (vm_size_t) s_section.size, TRUE);
  288.                         for (i = 0; i < s_section.size; i++) buffer[i] = NXGetc(stream);
  289.                     
  290.                         if((memory = NXOpenMemory(buffer, s_section.size, NX_READONLY)) != NULL) {
  291.                             if([self loadFromStream:memory]) {
  292. #ifdef DEBUG
  293.                                 (void) fprintf(stderr, "%s:%s:%s\n", filename, s_section.segname, s_section.sectname);
  294.                                 }
  295.                             else {
  296.                                 (void) fprintf(stderr, "%s:%s:%s -- failed\n", filename, s_section.segname, s_section.sectname);
  297. #endif
  298.                                 }
  299.                     
  300.                             NXCloseMemory(memory, NX_FREEBUFFER);
  301.                             }
  302.                         NXSeek(stream, offset, NX_FROMSTART);
  303.                         }
  304.                     }
  305.                 else NXSeek(stream, s_command.cmdsize - sizeof(s_command), NX_FROMCURRENT);
  306.                 }
  307.             else NXSeek(stream, l_command.cmdsize - sizeof(l_command), NX_FROMCURRENT);
  308.             }
  309.         }
  310.         
  311.     NXCloseMemory(stream, NX_FREEBUFFER);
  312.     
  313.     return self;
  314. }
  315.  
  316. @end
  317.